/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using MaxWindow11Stride4Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Max, pooling::Forward>;
TYPED_TEST_SUITE(MaxWindow11Stride4Forward, GTestTypePairs);
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {97.,  101., 105., 105., 157., 161.,
                                         165., 165., 217., 221., 225., 225.,
                                         217., 221., 225., 225.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 165., 221., 225.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193., 194., 201., 202., 209., 210., 209., 210., 313., 314., 321.,
      322., 329., 330., 329., 330., 433., 434., 441., 442., 449., 450.,
      449., 450., 433., 434., 441., 442., 449., 450., 449., 450.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321., 322., 329., 330.,
                                         441., 442., 449., 450.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      385., 386., 387., 388., 401., 402., 403., 404., 417., 418., 419.,
      420., 417., 418., 419., 420., 625., 626., 627., 628., 641., 642.,
      643., 644., 657., 658., 659., 660., 657., 658., 659., 660., 865.,
      866., 867., 868., 881., 882., 883., 884., 897., 898., 899., 900.,
      897., 898., 899., 900., 865., 866., 867., 868., 881., 882., 883.,
      884., 897., 898., 899., 900., 897., 898., 899., 900.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {641., 642., 643., 644., 657., 658.,
                                         659., 660., 881., 882., 883., 884.,
                                         897., 898., 899., 900.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {104., 108., 112., 112., 168., 172.,
                                         176., 176., 232., 236., 240., 240.,
                                         232., 236., 240., 240.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 175., 235., 239.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207., 208., 215., 216., 223., 224., 223., 224., 335., 336., 343.,
      344., 351., 352., 351., 352., 463., 464., 471., 472., 479., 480.,
      479., 480., 463., 464., 471., 472., 479., 480., 479., 480.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341., 342., 349., 350.,
                                         469., 470., 477., 478.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      413., 414., 415., 416., 429., 430., 431., 432., 445., 446., 447.,
      448., 445., 446., 447., 448., 669., 670., 671., 672., 685., 686.,
      687., 688., 701., 702., 703., 704., 701., 702., 703., 704., 925.,
      926., 927., 928., 941., 942., 943., 944., 957., 958., 959., 960.,
      957., 958., 959., 960., 925., 926., 927., 928., 941., 942., 943.,
      944., 957., 958., 959., 960., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {681., 682., 683., 684., 697., 698.,
                                         699., 700., 937., 938., 939., 940.,
                                         953., 954., 955., 956.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115., 119., 123., 126., 126., 187., 191., 195., 198., 198.,
      259., 263., 267., 270., 270., 259., 263., 267., 270., 270.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 195., 263., 267.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      229., 230., 237., 238., 245., 246., 251., 252., 251., 252.,
      373., 374., 381., 382., 389., 390., 395., 396., 395., 396.,
      517., 518., 525., 526., 533., 534., 539., 540., 539., 540.,
      517., 518., 525., 526., 533., 534., 539., 540., 539., 540.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381., 382., 389., 390.,
                                         525., 526., 533., 534.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      457.,  458.,  459.,  460.,  473.,  474.,  475.,  476.,  489.,  490.,
      491.,  492.,  501.,  502.,  503.,  504.,  501.,  502.,  503.,  504.,
      745.,  746.,  747.,  748.,  761.,  762.,  763.,  764.,  777.,  778.,
      779.,  780.,  789.,  790.,  791.,  792.,  789.,  790.,  791.,  792.,
      1033., 1034., 1035., 1036., 1049., 1050., 1051., 1052., 1065., 1066.,
      1067., 1068., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1033., 1034., 1035., 1036., 1049., 1050., 1051., 1052., 1065., 1066.,
      1067., 1068., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      761.,  762.,  763.,  764.,  777.,  778.,  779.,  780.,
      1049., 1050., 1051., 1052., 1065., 1066., 1067., 1068.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {112., 116., 120., 120., 172., 176.,
                                         180., 180., 232., 236., 240., 240.,
                                         232., 236., 240., 240.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 165., 221., 225.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223., 224., 231., 232., 239., 240., 239., 240., 343., 344., 351.,
      352., 359., 360., 359., 360., 463., 464., 471., 472., 479., 480.,
      479., 480., 463., 464., 471., 472., 479., 480., 479., 480.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321., 322., 329., 330.,
                                         441., 442., 449., 450.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      445., 446., 447., 448., 461., 462., 463., 464., 477., 478., 479.,
      480., 477., 478., 479., 480., 685., 686., 687., 688., 701., 702.,
      703., 704., 717., 718., 719., 720., 717., 718., 719., 720., 925.,
      926., 927., 928., 941., 942., 943., 944., 957., 958., 959., 960.,
      957., 958., 959., 960., 925., 926., 927., 928., 941., 942., 943.,
      944., 957., 958., 959., 960., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {641., 642., 643., 644., 657., 658.,
                                         659., 660., 881., 882., 883., 884.,
                                         897., 898., 899., 900.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {120., 124., 128., 128., 184., 188.,
                                         192., 192., 248., 252., 256., 256.,
                                         248., 252., 256., 256.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 175., 235., 239.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      239., 240., 247., 248., 255., 256., 255., 256., 367., 368., 375.,
      376., 383., 384., 383., 384., 495., 496., 503., 504., 511., 512.,
      511., 512., 495., 496., 503., 504., 511., 512., 511., 512.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341., 342., 349., 350.,
                                         469., 470., 477., 478.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      477.,  478.,  479.,  480.,  493.,  494.,  495.,  496.,  509.,  510.,
      511.,  512.,  509.,  510.,  511.,  512.,  733.,  734.,  735.,  736.,
      749.,  750.,  751.,  752.,  765.,  766.,  767.,  768.,  765.,  766.,
      767.,  768.,  989.,  990.,  991.,  992.,  1005., 1006., 1007., 1008.,
      1021., 1022., 1023., 1024., 1021., 1022., 1023., 1024., 989.,  990.,
      991.,  992.,  1005., 1006., 1007., 1008., 1021., 1022., 1023., 1024.,
      1021., 1022., 1023., 1024.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {681., 682., 683., 684., 697., 698.,
                                         699., 700., 937., 938., 939., 940.,
                                         953., 954., 955., 956.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 137., 141., 144., 144., 205., 209., 213., 216., 216.,
      277., 281., 285., 288., 288., 277., 281., 285., 288., 288.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 195., 263., 267.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265., 266., 273., 274., 281., 282., 287., 288., 287., 288.,
      409., 410., 417., 418., 425., 426., 431., 432., 431., 432.,
      553., 554., 561., 562., 569., 570., 575., 576., 575., 576.,
      553., 554., 561., 562., 569., 570., 575., 576., 575., 576.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381., 382., 389., 390.,
                                         525., 526., 533., 534.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      529.,  530.,  531.,  532.,  545.,  546.,  547.,  548.,  561.,  562.,
      563.,  564.,  573.,  574.,  575.,  576.,  573.,  574.,  575.,  576.,
      817.,  818.,  819.,  820.,  833.,  834.,  835.,  836.,  849.,  850.,
      851.,  852.,  861.,  862.,  863.,  864.,  861.,  862.,  863.,  864.,
      1105., 1106., 1107., 1108., 1121., 1122., 1123., 1124., 1137., 1138.,
      1139., 1140., 1149., 1150., 1151., 1152., 1149., 1150., 1151., 1152.,
      1105., 1106., 1107., 1108., 1121., 1122., 1123., 1124., 1137., 1138.,
      1139., 1140., 1149., 1150., 1151., 1152., 1149., 1150., 1151., 1152.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      761.,  762.,  763.,  764.,  777.,  778.,  779.,  780.,
      1049., 1050., 1051., 1052., 1065., 1066., 1067., 1068.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  101., 105., 105., 157., 161., 165., 165., 217., 221.,
      225., 225., 262., 266., 270., 270., 262., 266., 270., 270.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 165., 221., 225.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193., 194., 201., 202., 209., 210., 209., 210., 313., 314.,
      321., 322., 329., 330., 329., 330., 433., 434., 441., 442.,
      449., 450., 449., 450., 523., 524., 531., 532., 539., 540.,
      539., 540., 523., 524., 531., 532., 539., 540., 539., 540.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321., 322., 329., 330.,
                                         441., 442., 449., 450.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      385.,  386.,  387.,  388.,  401.,  402.,  403.,  404.,  417.,  418.,
      419.,  420.,  417.,  418.,  419.,  420.,  625.,  626.,  627.,  628.,
      641.,  642.,  643.,  644.,  657.,  658.,  659.,  660.,  657.,  658.,
      659.,  660.,  865.,  866.,  867.,  868.,  881.,  882.,  883.,  884.,
      897.,  898.,  899.,  900.,  897.,  898.,  899.,  900.,  1045., 1046.,
      1047., 1048., 1061., 1062., 1063., 1064., 1077., 1078., 1079., 1080.,
      1077., 1078., 1079., 1080., 1045., 1046., 1047., 1048., 1061., 1062.,
      1063., 1064., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {641., 642., 643., 644., 657., 658.,
                                         659., 660., 881., 882., 883., 884.,
                                         897., 898., 899., 900.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104., 108., 112., 112., 168., 172., 176., 176., 232., 236.,
      240., 240., 280., 284., 288., 288., 280., 284., 288., 288.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 175., 235., 239.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207., 208., 215., 216., 223., 224., 223., 224., 335., 336.,
      343., 344., 351., 352., 351., 352., 463., 464., 471., 472.,
      479., 480., 479., 480., 559., 560., 567., 568., 575., 576.,
      575., 576., 559., 560., 567., 568., 575., 576., 575., 576.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341., 342., 349., 350.,
                                         469., 470., 477., 478.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      413.,  414.,  415.,  416.,  429.,  430.,  431.,  432.,  445.,  446.,
      447.,  448.,  445.,  446.,  447.,  448.,  669.,  670.,  671.,  672.,
      685.,  686.,  687.,  688.,  701.,  702.,  703.,  704.,  701.,  702.,
      703.,  704.,  925.,  926.,  927.,  928.,  941.,  942.,  943.,  944.,
      957.,  958.,  959.,  960.,  957.,  958.,  959.,  960.,  1117., 1118.,
      1119., 1120., 1133., 1134., 1135., 1136., 1149., 1150., 1151., 1152.,
      1149., 1150., 1151., 1152., 1117., 1118., 1119., 1120., 1133., 1134.,
      1135., 1136., 1149., 1150., 1151., 1152., 1149., 1150., 1151., 1152.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {681., 682., 683., 684., 697., 698.,
                                         699., 700., 937., 938., 939., 940.,
                                         953., 954., 955., 956.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115., 119., 123., 126., 126., 187., 191., 195., 198.,
      198., 259., 263., 267., 270., 270., 313., 317., 321.,
      324., 324., 313., 317., 321., 324., 324.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 195., 263., 267.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      229., 230., 237., 238., 245., 246., 251., 252., 251., 252.,
      373., 374., 381., 382., 389., 390., 395., 396., 395., 396.,
      517., 518., 525., 526., 533., 534., 539., 540., 539., 540.,
      625., 626., 633., 634., 641., 642., 647., 648., 647., 648.,
      625., 626., 633., 634., 641., 642., 647., 648., 647., 648.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381., 382., 389., 390.,
                                         525., 526., 533., 534.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME1x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      457.,  458.,  459.,  460.,  473.,  474.,  475.,  476.,  489.,  490.,
      491.,  492.,  501.,  502.,  503.,  504.,  501.,  502.,  503.,  504.,
      745.,  746.,  747.,  748.,  761.,  762.,  763.,  764.,  777.,  778.,
      779.,  780.,  789.,  790.,  791.,  792.,  789.,  790.,  791.,  792.,
      1033., 1034., 1035., 1036., 1049., 1050., 1051., 1052., 1065., 1066.,
      1067., 1068., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1249., 1250., 1251., 1252., 1265., 1266., 1267., 1268., 1281., 1282.,
      1283., 1284., 1293., 1294., 1295., 1296., 1293., 1294., 1295., 1296.,
      1249., 1250., 1251., 1252., 1265., 1266., 1267., 1268., 1281., 1282.,
      1283., 1284., 1293., 1294., 1295., 1296., 1293., 1294., 1295., 1296.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID1x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      761.,  762.,  763.,  764.,  777.,  778.,  779.,  780.,
      1049., 1050., 1051., 1052., 1065., 1066., 1067., 1068.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  101., 105., 105., 157., 161., 165., 165., 217., 221., 225., 225.,
      217., 221., 225., 225., 322., 326., 330., 330., 382., 386., 390., 390.,
      442., 446., 450., 450., 442., 446., 450., 450., 547., 551., 555., 555.,
      607., 611., 615., 615., 667., 671., 675., 675., 667., 671., 675., 675.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 165., 221., 225., 386., 390.,
                                         446., 450., 611., 615., 671., 675.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193.,  194.,  201.,  202.,  209.,  210.,  209.,  210.,  313.,  314.,
      321.,  322.,  329.,  330.,  329.,  330.,  433.,  434.,  441.,  442.,
      449.,  450.,  449.,  450.,  433.,  434.,  441.,  442.,  449.,  450.,
      449.,  450.,  643.,  644.,  651.,  652.,  659.,  660.,  659.,  660.,
      763.,  764.,  771.,  772.,  779.,  780.,  779.,  780.,  883.,  884.,
      891.,  892.,  899.,  900.,  899.,  900.,  883.,  884.,  891.,  892.,
      899.,  900.,  899.,  900.,  1093., 1094., 1101., 1102., 1109., 1110.,
      1109., 1110., 1213., 1214., 1221., 1222., 1229., 1230., 1229., 1230.,
      1333., 1334., 1341., 1342., 1349., 1350., 1349., 1350., 1333., 1334.,
      1341., 1342., 1349., 1350., 1349., 1350.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      321.,  322.,  329.,  330.,  441.,  442.,  449.,  450.,
      771.,  772.,  779.,  780.,  891.,  892.,  899.,  900.,
      1221., 1222., 1229., 1230., 1341., 1342., 1349., 1350.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      385.,  386.,  387.,  388.,  401.,  402.,  403.,  404.,  417.,  418.,
      419.,  420.,  417.,  418.,  419.,  420.,  625.,  626.,  627.,  628.,
      641.,  642.,  643.,  644.,  657.,  658.,  659.,  660.,  657.,  658.,
      659.,  660.,  865.,  866.,  867.,  868.,  881.,  882.,  883.,  884.,
      897.,  898.,  899.,  900.,  897.,  898.,  899.,  900.,  865.,  866.,
      867.,  868.,  881.,  882.,  883.,  884.,  897.,  898.,  899.,  900.,
      897.,  898.,  899.,  900.,  1285., 1286., 1287., 1288., 1301., 1302.,
      1303., 1304., 1317., 1318., 1319., 1320., 1317., 1318., 1319., 1320.,
      1525., 1526., 1527., 1528., 1541., 1542., 1543., 1544., 1557., 1558.,
      1559., 1560., 1557., 1558., 1559., 1560., 1765., 1766., 1767., 1768.,
      1781., 1782., 1783., 1784., 1797., 1798., 1799., 1800., 1797., 1798.,
      1799., 1800., 1765., 1766., 1767., 1768., 1781., 1782., 1783., 1784.,
      1797., 1798., 1799., 1800., 1797., 1798., 1799., 1800., 2045., 2046.,
      2047., 2048., 2045., 2046., 2047., 2048., 2037., 2038., 2039., 2040.,
      2037., 2038., 2039., 2040., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2037., 2038., 2039., 2040., 2037., 2038., 2039., 2040.,
      2045., 2046., 2047., 2048., 2045., 2046., 2047., 2048., 649.,  650.,
      651.,  652.,  649.,  650.,  651.,  652.,  617.,  618.,  619.,  620.,
      633.,  634.,  635.,  636.,  649.,  650.,  651.,  652.,  649.,  650.,
      651.,  652.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      641.,  642.,  643.,  644.,  657.,  658.,  659.,  660.,  881.,  882.,
      883.,  884.,  897.,  898.,  899.,  900.,  1541., 1542., 1543., 1544.,
      1557., 1558., 1559., 1560., 1781., 1782., 1783., 1784., 1797., 1798.,
      1799., 1800., 2045., 2046., 2047., 2048., 2037., 2038., 2039., 2040.,
      2045., 2046., 2047., 2048., 649.,  650.,  651.,  652.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104., 108., 112., 112., 168., 172., 176., 176., 232., 236., 240., 240.,
      232., 236., 240., 240., 344., 348., 352., 352., 408., 412., 416., 416.,
      472., 476., 480., 480., 472., 476., 480., 480., 584., 588., 592., 592.,
      648., 652., 656., 656., 712., 716., 720., 720., 712., 716., 720., 720.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 175., 235., 239., 411., 415.,
                                         475., 479., 651., 655., 715., 719.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207.,  208.,  215.,  216.,  223.,  224.,  223.,  224.,  335.,  336.,
      343.,  344.,  351.,  352.,  351.,  352.,  463.,  464.,  471.,  472.,
      479.,  480.,  479.,  480.,  463.,  464.,  471.,  472.,  479.,  480.,
      479.,  480.,  687.,  688.,  695.,  696.,  703.,  704.,  703.,  704.,
      815.,  816.,  823.,  824.,  831.,  832.,  831.,  832.,  943.,  944.,
      951.,  952.,  959.,  960.,  959.,  960.,  943.,  944.,  951.,  952.,
      959.,  960.,  959.,  960.,  1167., 1168., 1175., 1176., 1183., 1184.,
      1183., 1184., 1295., 1296., 1303., 1304., 1311., 1312., 1311., 1312.,
      1423., 1424., 1431., 1432., 1439., 1440., 1439., 1440., 1423., 1424.,
      1431., 1432., 1439., 1440., 1439., 1440.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      341.,  342.,  349.,  350.,  469.,  470.,  477.,  478.,
      821.,  822.,  829.,  830.,  949.,  950.,  957.,  958.,
      1301., 1302., 1309., 1310., 1429., 1430., 1437., 1438.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      413.,  414.,  415.,  416.,  429.,  430.,  431.,  432.,  445.,  446.,
      447.,  448.,  445.,  446.,  447.,  448.,  669.,  670.,  671.,  672.,
      685.,  686.,  687.,  688.,  701.,  702.,  703.,  704.,  701.,  702.,
      703.,  704.,  925.,  926.,  927.,  928.,  941.,  942.,  943.,  944.,
      957.,  958.,  959.,  960.,  957.,  958.,  959.,  960.,  925.,  926.,
      927.,  928.,  941.,  942.,  943.,  944.,  957.,  958.,  959.,  960.,
      957.,  958.,  959.,  960.,  1373., 1374., 1375., 1376., 1389., 1390.,
      1391., 1392., 1405., 1406., 1407., 1408., 1405., 1406., 1407., 1408.,
      1629., 1630., 1631., 1632., 1645., 1646., 1647., 1648., 1661., 1662.,
      1663., 1664., 1661., 1662., 1663., 1664., 1885., 1886., 1887., 1888.,
      1901., 1902., 1903., 1904., 1917., 1918., 1919., 1920., 1917., 1918.,
      1919., 1920., 1885., 1886., 1887., 1888., 1901., 1902., 1903., 1904.,
      1917., 1918., 1919., 1920., 1917., 1918., 1919., 1920., 2013., 2014.,
      2015., 2016., 2029., 2030., 2031., 2032., 2045., 2046., 2047., 2048.,
      2045., 2046., 2047., 2048., 2013., 2014., 2015., 2016., 2029., 2030.,
      2031., 2032., 2045., 2046., 2047., 2048., 2045., 2046., 2047., 2048.,
      797.,  798.,  799.,  800.,  813.,  814.,  815.,  816.,  829.,  830.,
      831.,  832.,  829.,  830.,  831.,  832.,  797.,  798.,  799.,  800.,
      813.,  814.,  815.,  816.,  829.,  830.,  831.,  832.,  829.,  830.,
      831.,  832.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      681.,  682.,  683.,  684.,  697.,  698.,  699.,  700.,  937.,  938.,
      939.,  940.,  953.,  954.,  955.,  956.,  1641., 1642., 1643., 1644.,
      1657., 1658., 1659., 1660., 1897., 1898., 1899., 1900., 1913., 1914.,
      1915., 1916., 2025., 2026., 2027., 2028., 2041., 2042., 2043., 2044.,
      809.,  810.,  811.,  812.,  825.,  826.,  827.,  828.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115., 119., 123., 126., 126., 187., 191., 195., 198., 198., 259., 263.,
      267., 270., 270., 259., 263., 267., 270., 270., 385., 389., 393., 396.,
      396., 457., 461., 465., 468., 468., 529., 533., 537., 540., 540., 529.,
      533., 537., 540., 540., 655., 659., 663., 666., 666., 727., 731., 735.,
      738., 738., 799., 803., 807., 810., 810., 799., 803., 807., 810., 810.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 195., 263., 267., 461., 465.,
                                         533., 537., 731., 735., 803., 807.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      229.,  230.,  237.,  238.,  245.,  246.,  251.,  252.,  251.,  252.,
      373.,  374.,  381.,  382.,  389.,  390.,  395.,  396.,  395.,  396.,
      517.,  518.,  525.,  526.,  533.,  534.,  539.,  540.,  539.,  540.,
      517.,  518.,  525.,  526.,  533.,  534.,  539.,  540.,  539.,  540.,
      769.,  770.,  777.,  778.,  785.,  786.,  791.,  792.,  791.,  792.,
      913.,  914.,  921.,  922.,  929.,  930.,  935.,  936.,  935.,  936.,
      1057., 1058., 1065., 1066., 1073., 1074., 1079., 1080., 1079., 1080.,
      1057., 1058., 1065., 1066., 1073., 1074., 1079., 1080., 1079., 1080.,
      1309., 1310., 1317., 1318., 1325., 1326., 1331., 1332., 1331., 1332.,
      1453., 1454., 1461., 1462., 1469., 1470., 1475., 1476., 1475., 1476.,
      1597., 1598., 1605., 1606., 1613., 1614., 1619., 1620., 1619., 1620.,
      1597., 1598., 1605., 1606., 1613., 1614., 1619., 1620., 1619., 1620.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      381.,  382.,  389.,  390.,  525.,  526.,  533.,  534.,
      921.,  922.,  929.,  930.,  1065., 1066., 1073., 1074.,
      1461., 1462., 1469., 1470., 1605., 1606., 1613., 1614.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      457.,  458.,  459.,  460.,  473.,  474.,  475.,  476.,  489.,  490.,
      491.,  492.,  501.,  502.,  503.,  504.,  501.,  502.,  503.,  504.,
      745.,  746.,  747.,  748.,  761.,  762.,  763.,  764.,  777.,  778.,
      779.,  780.,  789.,  790.,  791.,  792.,  789.,  790.,  791.,  792.,
      1033., 1034., 1035., 1036., 1049., 1050., 1051., 1052., 1065., 1066.,
      1067., 1068., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1033., 1034., 1035., 1036., 1049., 1050., 1051., 1052., 1065., 1066.,
      1067., 1068., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1537., 1538., 1539., 1540., 1553., 1554., 1555., 1556., 1569., 1570.,
      1571., 1572., 1581., 1582., 1583., 1584., 1581., 1582., 1583., 1584.,
      1825., 1826., 1827., 1828., 1841., 1842., 1843., 1844., 1857., 1858.,
      1859., 1860., 1869., 1870., 1871., 1872., 1869., 1870., 1871., 1872.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      569.,  570.,  571.,  572.,  585.,  586.,  587.,  588.,  601.,  602.,
      603.,  604.,  613.,  614.,  615.,  616.,  613.,  614.,  615.,  616.,
      857.,  858.,  859.,  860.,  873.,  874.,  875.,  876.,  889.,  890.,
      891.,  892.,  901.,  902.,  903.,  904.,  901.,  902.,  903.,  904.,
      1145., 1146., 1147., 1148., 1161., 1162., 1163., 1164., 1177., 1178.,
      1179., 1180., 1189., 1190., 1191., 1192., 1189., 1190., 1191., 1192.,
      1145., 1146., 1147., 1148., 1161., 1162., 1163., 1164., 1177., 1178.,
      1179., 1180., 1189., 1190., 1191., 1192., 1189., 1190., 1191., 1192.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      761.,  762.,  763.,  764.,  777.,  778.,  779.,  780.,  1049., 1050.,
      1051., 1052., 1065., 1066., 1067., 1068., 1841., 1842., 1843., 1844.,
      1857., 1858., 1859., 1860., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 873.,  874.,  875.,  876.,  889.,  890.,  891.,  892.,
      1161., 1162., 1163., 1164., 1177., 1178., 1179., 1180.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      112., 116., 120., 120., 172., 176., 180., 180., 232., 236., 240., 240.,
      232., 236., 240., 240., 352., 356., 360., 360., 412., 416., 420., 420.,
      472., 476., 480., 480., 472., 476., 480., 480., 592., 596., 600., 600.,
      652., 656., 660., 660., 712., 716., 720., 720., 712., 716., 720., 720.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 165., 221., 225., 401., 405.,
                                         461., 465., 641., 645., 701., 705.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223.,  224.,  231.,  232.,  239.,  240.,  239.,  240.,  343.,  344.,
      351.,  352.,  359.,  360.,  359.,  360.,  463.,  464.,  471.,  472.,
      479.,  480.,  479.,  480.,  463.,  464.,  471.,  472.,  479.,  480.,
      479.,  480.,  703.,  704.,  711.,  712.,  719.,  720.,  719.,  720.,
      823.,  824.,  831.,  832.,  839.,  840.,  839.,  840.,  943.,  944.,
      951.,  952.,  959.,  960.,  959.,  960.,  943.,  944.,  951.,  952.,
      959.,  960.,  959.,  960.,  1183., 1184., 1191., 1192., 1199., 1200.,
      1199., 1200., 1303., 1304., 1311., 1312., 1319., 1320., 1319., 1320.,
      1423., 1424., 1431., 1432., 1439., 1440., 1439., 1440., 1423., 1424.,
      1431., 1432., 1439., 1440., 1439., 1440.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      321.,  322.,  329.,  330.,  441.,  442.,  449.,  450.,
      801.,  802.,  809.,  810.,  921.,  922.,  929.,  930.,
      1281., 1282., 1289., 1290., 1401., 1402., 1409., 1410.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      445.,  446.,  447.,  448.,  461.,  462.,  463.,  464.,  477.,  478.,
      479.,  480.,  477.,  478.,  479.,  480.,  685.,  686.,  687.,  688.,
      701.,  702.,  703.,  704.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  925.,  926.,  927.,  928.,  941.,  942.,  943.,  944.,
      957.,  958.,  959.,  960.,  957.,  958.,  959.,  960.,  925.,  926.,
      927.,  928.,  941.,  942.,  943.,  944.,  957.,  958.,  959.,  960.,
      957.,  958.,  959.,  960.,  1405., 1406., 1407., 1408., 1421., 1422.,
      1423., 1424., 1437., 1438., 1439., 1440., 1437., 1438., 1439., 1440.,
      1645., 1646., 1647., 1648., 1661., 1662., 1663., 1664., 1677., 1678.,
      1679., 1680., 1677., 1678., 1679., 1680., 1885., 1886., 1887., 1888.,
      1901., 1902., 1903., 1904., 1917., 1918., 1919., 1920., 1917., 1918.,
      1919., 1920., 1885., 1886., 1887., 1888., 1901., 1902., 1903., 1904.,
      1917., 1918., 1919., 1920., 1917., 1918., 1919., 1920., 2045., 2046.,
      2047., 2048., 2045., 2046., 2047., 2048., 2037., 2038., 2039., 2040.,
      2037., 2038., 2039., 2040., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2037., 2038., 2039., 2040., 2037., 2038., 2039., 2040.,
      797.,  798.,  799.,  800.,  813.,  814.,  815.,  816.,  829.,  830.,
      831.,  832.,  829.,  830.,  831.,  832.,  797.,  798.,  799.,  800.,
      813.,  814.,  815.,  816.,  829.,  830.,  831.,  832.,  829.,  830.,
      831.,  832.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      641.,  642.,  643.,  644.,  657.,  658.,  659.,  660.,  881.,  882.,
      883.,  884.,  897.,  898.,  899.,  900.,  1601., 1602., 1603., 1604.,
      1617., 1618., 1619., 1620., 1841., 1842., 1843., 1844., 1857., 1858.,
      1859., 1860., 2045., 2046., 2047., 2048., 2037., 2038., 2039., 2040.,
      753.,  754.,  755.,  756.,  769.,  770.,  771.,  772.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120., 124., 128., 128., 184., 188., 192., 192., 248., 252., 256., 256.,
      248., 252., 256., 256., 376., 380., 384., 384., 440., 444., 448., 448.,
      504., 508., 512., 512., 504., 508., 512., 512., 632., 636., 640., 640.,
      696., 700., 704., 704., 760., 764., 768., 768., 760., 764., 768., 768.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 175., 235., 239., 427., 431.,
                                         491., 495., 683., 687., 747., 751.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      239.,  240.,  247.,  248.,  255.,  256.,  255.,  256.,  367.,  368.,
      375.,  376.,  383.,  384.,  383.,  384.,  495.,  496.,  503.,  504.,
      511.,  512.,  511.,  512.,  495.,  496.,  503.,  504.,  511.,  512.,
      511.,  512.,  751.,  752.,  759.,  760.,  767.,  768.,  767.,  768.,
      879.,  880.,  887.,  888.,  895.,  896.,  895.,  896.,  1007., 1008.,
      1015., 1016., 1023., 1024., 1023., 1024., 1007., 1008., 1015., 1016.,
      1023., 1024., 1023., 1024., 1263., 1264., 1271., 1272., 1279., 1280.,
      1279., 1280., 1391., 1392., 1399., 1400., 1407., 1408., 1407., 1408.,
      1519., 1520., 1527., 1528., 1535., 1536., 1535., 1536., 1519., 1520.,
      1527., 1528., 1535., 1536., 1535., 1536.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      341.,  342.,  349.,  350.,  469.,  470.,  477.,  478.,
      853.,  854.,  861.,  862.,  981.,  982.,  989.,  990.,
      1365., 1366., 1373., 1374., 1493., 1494., 1501., 1502.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      477.,  478.,  479.,  480.,  493.,  494.,  495.,  496.,  509.,  510.,
      511.,  512.,  509.,  510.,  511.,  512.,  733.,  734.,  735.,  736.,
      749.,  750.,  751.,  752.,  765.,  766.,  767.,  768.,  765.,  766.,
      767.,  768.,  989.,  990.,  991.,  992.,  1005., 1006., 1007., 1008.,
      1021., 1022., 1023., 1024., 1021., 1022., 1023., 1024., 989.,  990.,
      991.,  992.,  1005., 1006., 1007., 1008., 1021., 1022., 1023., 1024.,
      1021., 1022., 1023., 1024., 1501., 1502., 1503., 1504., 1517., 1518.,
      1519., 1520., 1533., 1534., 1535., 1536., 1533., 1534., 1535., 1536.,
      1757., 1758., 1759., 1760., 1773., 1774., 1775., 1776., 1789., 1790.,
      1791., 1792., 1789., 1790., 1791., 1792., 2013., 2014., 2015., 2016.,
      2029., 2030., 2031., 2032., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2029., 2030., 2031., 2032.,
      2045., 2046., 2047., 2048., 2045., 2046., 2047., 2048., 477.,  478.,
      479.,  480.,  493.,  494.,  495.,  496.,  509.,  510.,  511.,  512.,
      509.,  510.,  511.,  512.,  733.,  734.,  735.,  736.,  749.,  750.,
      751.,  752.,  765.,  766.,  767.,  768.,  765.,  766.,  767.,  768.,
      989.,  990.,  991.,  992.,  1005., 1006., 1007., 1008., 1021., 1022.,
      1023., 1024., 1021., 1022., 1023., 1024., 989.,  990.,  991.,  992.,
      1005., 1006., 1007., 1008., 1021., 1022., 1023., 1024., 1021., 1022.,
      1023., 1024.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      681.,  682.,  683.,  684.,  697.,  698.,  699.,  700.,  937.,  938.,
      939.,  940.,  953.,  954.,  955.,  956.,  1705., 1706., 1707., 1708.,
      1721., 1722., 1723., 1724., 1961., 1962., 1963., 1964., 1977., 1978.,
      1979., 1980., 681.,  682.,  683.,  684.,  697.,  698.,  699.,  700.,
      937.,  938.,  939.,  940.,  953.,  954.,  955.,  956.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 137., 141., 144., 144., 205., 209., 213., 216., 216., 277., 281.,
      285., 288., 288., 277., 281., 285., 288., 288., 421., 425., 429., 432.,
      432., 493., 497., 501., 504., 504., 565., 569., 573., 576., 576., 565.,
      569., 573., 576., 576., 709., 713., 717., 720., 720., 781., 785., 789.,
      792., 792., 853., 857., 861., 864., 864., 853., 857., 861., 864., 864.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 195., 263., 267., 479., 483.,
                                         551., 555., 767., 771., 839., 843.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265.,  266.,  273.,  274.,  281.,  282.,  287.,  288.,  287.,  288.,
      409.,  410.,  417.,  418.,  425.,  426.,  431.,  432.,  431.,  432.,
      553.,  554.,  561.,  562.,  569.,  570.,  575.,  576.,  575.,  576.,
      553.,  554.,  561.,  562.,  569.,  570.,  575.,  576.,  575.,  576.,
      841.,  842.,  849.,  850.,  857.,  858.,  863.,  864.,  863.,  864.,
      985.,  986.,  993.,  994.,  1001., 1002., 1007., 1008., 1007., 1008.,
      1129., 1130., 1137., 1138., 1145., 1146., 1151., 1152., 1151., 1152.,
      1129., 1130., 1137., 1138., 1145., 1146., 1151., 1152., 1151., 1152.,
      1417., 1418., 1425., 1426., 1433., 1434., 1439., 1440., 1439., 1440.,
      1561., 1562., 1569., 1570., 1577., 1578., 1583., 1584., 1583., 1584.,
      1705., 1706., 1713., 1714., 1721., 1722., 1727., 1728., 1727., 1728.,
      1705., 1706., 1713., 1714., 1721., 1722., 1727., 1728., 1727., 1728.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      381.,  382.,  389.,  390.,  525.,  526.,  533.,  534.,
      957.,  958.,  965.,  966.,  1101., 1102., 1109., 1110.,
      1533., 1534., 1541., 1542., 1677., 1678., 1685., 1686.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      529.,  530.,  531.,  532.,  545.,  546.,  547.,  548.,  561.,  562.,
      563.,  564.,  573.,  574.,  575.,  576.,  573.,  574.,  575.,  576.,
      817.,  818.,  819.,  820.,  833.,  834.,  835.,  836.,  849.,  850.,
      851.,  852.,  861.,  862.,  863.,  864.,  861.,  862.,  863.,  864.,
      1105., 1106., 1107., 1108., 1121., 1122., 1123., 1124., 1137., 1138.,
      1139., 1140., 1149., 1150., 1151., 1152., 1149., 1150., 1151., 1152.,
      1105., 1106., 1107., 1108., 1121., 1122., 1123., 1124., 1137., 1138.,
      1139., 1140., 1149., 1150., 1151., 1152., 1149., 1150., 1151., 1152.,
      1681., 1682., 1683., 1684., 1697., 1698., 1699., 1700., 1713., 1714.,
      1715., 1716., 1725., 1726., 1727., 1728., 1725., 1726., 1727., 1728.,
      1969., 1970., 1971., 1972., 1985., 1986., 1987., 1988., 2001., 2002.,
      2003., 2004., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      785.,  786.,  787.,  788.,  801.,  802.,  803.,  804.,  817.,  818.,
      819.,  820.,  829.,  830.,  831.,  832.,  829.,  830.,  831.,  832.,
      1073., 1074., 1075., 1076., 1089., 1090., 1091., 1092., 1105., 1106.,
      1107., 1108., 1117., 1118., 1119., 1120., 1117., 1118., 1119., 1120.,
      1361., 1362., 1363., 1364., 1377., 1378., 1379., 1380., 1393., 1394.,
      1395., 1396., 1405., 1406., 1407., 1408., 1405., 1406., 1407., 1408.,
      1361., 1362., 1363., 1364., 1377., 1378., 1379., 1380., 1393., 1394.,
      1395., 1396., 1405., 1406., 1407., 1408., 1405., 1406., 1407., 1408.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      761.,  762.,  763.,  764.,  777.,  778.,  779.,  780.,  1049., 1050.,
      1051., 1052., 1065., 1066., 1067., 1068., 1913., 1914., 1915., 1916.,
      1929., 1930., 1931., 1932., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 1017., 1018., 1019., 1020., 1033., 1034., 1035., 1036.,
      1305., 1306., 1307., 1308., 1321., 1322., 1323., 1324.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  101., 105., 105., 157., 161., 165., 165., 217., 221., 225., 225.,
      262., 266., 270., 270., 262., 266., 270., 270., 367., 371., 375., 375.,
      427., 431., 435., 435., 487., 491., 495., 495., 532., 536., 540., 540.,
      532., 536., 540., 540., 637., 641., 645., 645., 697., 701., 705., 705.,
      757., 761., 765., 765., 802., 806., 810., 810., 802., 806., 810., 810.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 165., 221., 225., 431., 435.,
                                         491., 495., 701., 705., 761., 765.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193.,  194.,  201.,  202.,  209.,  210.,  209.,  210.,  313.,  314.,
      321.,  322.,  329.,  330.,  329.,  330.,  433.,  434.,  441.,  442.,
      449.,  450.,  449.,  450.,  523.,  524.,  531.,  532.,  539.,  540.,
      539.,  540.,  523.,  524.,  531.,  532.,  539.,  540.,  539.,  540.,
      733.,  734.,  741.,  742.,  749.,  750.,  749.,  750.,  853.,  854.,
      861.,  862.,  869.,  870.,  869.,  870.,  973.,  974.,  981.,  982.,
      989.,  990.,  989.,  990.,  1063., 1064., 1071., 1072., 1079., 1080.,
      1079., 1080., 1063., 1064., 1071., 1072., 1079., 1080., 1079., 1080.,
      1273., 1274., 1281., 1282., 1289., 1290., 1289., 1290., 1393., 1394.,
      1401., 1402., 1409., 1410., 1409., 1410., 1513., 1514., 1521., 1522.,
      1529., 1530., 1529., 1530., 1603., 1604., 1611., 1612., 1619., 1620.,
      1619., 1620., 1603., 1604., 1611., 1612., 1619., 1620., 1619., 1620.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      321.,  322.,  329.,  330.,  441.,  442.,  449.,  450.,
      861.,  862.,  869.,  870.,  981.,  982.,  989.,  990.,
      1401., 1402., 1409., 1410., 1521., 1522., 1529., 1530.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      385.,  386.,  387.,  388.,  401.,  402.,  403.,  404.,  417.,  418.,
      419.,  420.,  417.,  418.,  419.,  420.,  625.,  626.,  627.,  628.,
      641.,  642.,  643.,  644.,  657.,  658.,  659.,  660.,  657.,  658.,
      659.,  660.,  865.,  866.,  867.,  868.,  881.,  882.,  883.,  884.,
      897.,  898.,  899.,  900.,  897.,  898.,  899.,  900.,  1045., 1046.,
      1047., 1048., 1061., 1062., 1063., 1064., 1077., 1078., 1079., 1080.,
      1077., 1078., 1079., 1080., 1045., 1046., 1047., 1048., 1061., 1062.,
      1063., 1064., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1465., 1466., 1467., 1468., 1481., 1482., 1483., 1484., 1497., 1498.,
      1499., 1500., 1497., 1498., 1499., 1500., 1705., 1706., 1707., 1708.,
      1721., 1722., 1723., 1724., 1737., 1738., 1739., 1740., 1737., 1738.,
      1739., 1740., 1945., 1946., 1947., 1948., 1961., 1962., 1963., 1964.,
      1977., 1978., 1979., 1980., 1977., 1978., 1979., 1980., 2045., 2046.,
      2047., 2048., 2045., 2046., 2047., 2048., 2037., 2038., 2039., 2040.,
      2037., 2038., 2039., 2040., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2037., 2038., 2039., 2040., 2037., 2038., 2039., 2040.,
      497.,  498.,  499.,  500.,  513.,  514.,  515.,  516.,  529.,  530.,
      531.,  532.,  529.,  530.,  531.,  532.,  737.,  738.,  739.,  740.,
      753.,  754.,  755.,  756.,  769.,  770.,  771.,  772.,  769.,  770.,
      771.,  772.,  977.,  978.,  979.,  980.,  993.,  994.,  995.,  996.,
      1009., 1010., 1011., 1012., 1009., 1010., 1011., 1012., 1157., 1158.,
      1159., 1160., 1173., 1174., 1175., 1176., 1189., 1190., 1191., 1192.,
      1189., 1190., 1191., 1192., 1157., 1158., 1159., 1160., 1173., 1174.,
      1175., 1176., 1189., 1190., 1191., 1192., 1189., 1190., 1191., 1192.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      641.,  642.,  643.,  644.,  657.,  658.,  659.,  660.,  881.,  882.,
      883.,  884.,  897.,  898.,  899.,  900.,  1721., 1722., 1723., 1724.,
      1737., 1738., 1739., 1740., 1961., 1962., 1963., 1964., 1977., 1978.,
      1979., 1980., 753.,  754.,  755.,  756.,  769.,  770.,  771.,  772.,
      993.,  994.,  995.,  996.,  1009., 1010., 1011., 1012.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104., 108., 112., 112., 168., 172., 176., 176., 232., 236., 240., 240.,
      280., 284., 288., 288., 280., 284., 288., 288., 392., 396., 400., 400.,
      456., 460., 464., 464., 520., 524., 528., 528., 568., 572., 576., 576.,
      568., 572., 576., 576., 680., 684., 688., 688., 744., 748., 752., 752.,
      808., 812., 816., 816., 856., 860., 864., 864., 856., 860., 864., 864.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 175., 235., 239., 459., 463.,
                                         523., 527., 747., 751., 811., 815.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207.,  208.,  215.,  216.,  223.,  224.,  223.,  224.,  335.,  336.,
      343.,  344.,  351.,  352.,  351.,  352.,  463.,  464.,  471.,  472.,
      479.,  480.,  479.,  480.,  559.,  560.,  567.,  568.,  575.,  576.,
      575.,  576.,  559.,  560.,  567.,  568.,  575.,  576.,  575.,  576.,
      783.,  784.,  791.,  792.,  799.,  800.,  799.,  800.,  911.,  912.,
      919.,  920.,  927.,  928.,  927.,  928.,  1039., 1040., 1047., 1048.,
      1055., 1056., 1055., 1056., 1135., 1136., 1143., 1144., 1151., 1152.,
      1151., 1152., 1135., 1136., 1143., 1144., 1151., 1152., 1151., 1152.,
      1359., 1360., 1367., 1368., 1375., 1376., 1375., 1376., 1487., 1488.,
      1495., 1496., 1503., 1504., 1503., 1504., 1615., 1616., 1623., 1624.,
      1631., 1632., 1631., 1632., 1711., 1712., 1719., 1720., 1727., 1728.,
      1727., 1728., 1711., 1712., 1719., 1720., 1727., 1728., 1727., 1728.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      341.,  342.,  349.,  350.,  469.,  470.,  477.,  478.,
      917.,  918.,  925.,  926.,  1045., 1046., 1053., 1054.,
      1493., 1494., 1501., 1502., 1621., 1622., 1629., 1630.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      413.,  414.,  415.,  416.,  429.,  430.,  431.,  432.,  445.,  446.,
      447.,  448.,  445.,  446.,  447.,  448.,  669.,  670.,  671.,  672.,
      685.,  686.,  687.,  688.,  701.,  702.,  703.,  704.,  701.,  702.,
      703.,  704.,  925.,  926.,  927.,  928.,  941.,  942.,  943.,  944.,
      957.,  958.,  959.,  960.,  957.,  958.,  959.,  960.,  1117., 1118.,
      1119., 1120., 1133., 1134., 1135., 1136., 1149., 1150., 1151., 1152.,
      1149., 1150., 1151., 1152., 1117., 1118., 1119., 1120., 1133., 1134.,
      1135., 1136., 1149., 1150., 1151., 1152., 1149., 1150., 1151., 1152.,
      1565., 1566., 1567., 1568., 1581., 1582., 1583., 1584., 1597., 1598.,
      1599., 1600., 1597., 1598., 1599., 1600., 1821., 1822., 1823., 1824.,
      1837., 1838., 1839., 1840., 1853., 1854., 1855., 1856., 1853., 1854.,
      1855., 1856., 2013., 2014., 2015., 2016., 2029., 2030., 2031., 2032.,
      2045., 2046., 2047., 2048., 2045., 2046., 2047., 2048., 2013., 2014.,
      2015., 2016., 2029., 2030., 2031., 2032., 2045., 2046., 2047., 2048.,
      2045., 2046., 2047., 2048., 2013., 2014., 2015., 2016., 2029., 2030.,
      2031., 2032., 2045., 2046., 2047., 2048., 2045., 2046., 2047., 2048.,
      669.,  670.,  671.,  672.,  685.,  686.,  687.,  688.,  701.,  702.,
      703.,  704.,  701.,  702.,  703.,  704.,  925.,  926.,  927.,  928.,
      941.,  942.,  943.,  944.,  957.,  958.,  959.,  960.,  957.,  958.,
      959.,  960.,  1181., 1182., 1183., 1184., 1197., 1198., 1199., 1200.,
      1213., 1214., 1215., 1216., 1213., 1214., 1215., 1216., 1373., 1374.,
      1375., 1376., 1389., 1390., 1391., 1392., 1405., 1406., 1407., 1408.,
      1405., 1406., 1407., 1408., 1373., 1374., 1375., 1376., 1389., 1390.,
      1391., 1392., 1405., 1406., 1407., 1408., 1405., 1406., 1407., 1408.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      681.,  682.,  683.,  684.,  697.,  698.,  699.,  700.,  937.,  938.,
      939.,  940.,  953.,  954.,  955.,  956.,  1833., 1834., 1835., 1836.,
      1849., 1850., 1851., 1852., 2025., 2026., 2027., 2028., 2041., 2042.,
      2043., 2044., 937.,  938.,  939.,  940.,  953.,  954.,  955.,  956.,
      1193., 1194., 1195., 1196., 1209., 1210., 1211., 1212.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115., 119., 123., 126., 126., 187., 191., 195., 198., 198., 259.,
      263., 267., 270., 270., 313., 317., 321., 324., 324., 313., 317.,
      321., 324., 324., 439., 443., 447., 450., 450., 511., 515., 519.,
      522., 522., 583., 587., 591., 594., 594., 637., 641., 645., 648.,
      648., 637., 641., 645., 648., 648., 763., 767., 771., 774., 774.,
      835., 839., 843., 846., 846., 907., 911., 915., 918., 918., 961.,
      965., 969., 972., 972., 961., 965., 969., 972., 972.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 195., 263., 267., 515., 519.,
                                         587., 591., 839., 843., 911., 915.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      229.,  230.,  237.,  238.,  245.,  246.,  251.,  252.,  251.,  252.,
      373.,  374.,  381.,  382.,  389.,  390.,  395.,  396.,  395.,  396.,
      517.,  518.,  525.,  526.,  533.,  534.,  539.,  540.,  539.,  540.,
      625.,  626.,  633.,  634.,  641.,  642.,  647.,  648.,  647.,  648.,
      625.,  626.,  633.,  634.,  641.,  642.,  647.,  648.,  647.,  648.,
      877.,  878.,  885.,  886.,  893.,  894.,  899.,  900.,  899.,  900.,
      1021., 1022., 1029., 1030., 1037., 1038., 1043., 1044., 1043., 1044.,
      1165., 1166., 1173., 1174., 1181., 1182., 1187., 1188., 1187., 1188.,
      1273., 1274., 1281., 1282., 1289., 1290., 1295., 1296., 1295., 1296.,
      1273., 1274., 1281., 1282., 1289., 1290., 1295., 1296., 1295., 1296.,
      1525., 1526., 1533., 1534., 1541., 1542., 1547., 1548., 1547., 1548.,
      1669., 1670., 1677., 1678., 1685., 1686., 1691., 1692., 1691., 1692.,
      1813., 1814., 1821., 1822., 1829., 1830., 1835., 1836., 1835., 1836.,
      1921., 1922., 1929., 1930., 1937., 1938., 1943., 1944., 1943., 1944.,
      1921., 1922., 1929., 1930., 1937., 1938., 1943., 1944., 1943., 1944.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      381.,  382.,  389.,  390.,  525.,  526.,  533.,  534.,
      1029., 1030., 1037., 1038., 1173., 1174., 1181., 1182.,
      1677., 1678., 1685., 1686., 1821., 1822., 1829., 1830.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, SAME3x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      457.,  458.,  459.,  460.,  473.,  474.,  475.,  476.,  489.,  490.,
      491.,  492.,  501.,  502.,  503.,  504.,  501.,  502.,  503.,  504.,
      745.,  746.,  747.,  748.,  761.,  762.,  763.,  764.,  777.,  778.,
      779.,  780.,  789.,  790.,  791.,  792.,  789.,  790.,  791.,  792.,
      1033., 1034., 1035., 1036., 1049., 1050., 1051., 1052., 1065., 1066.,
      1067., 1068., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1249., 1250., 1251., 1252., 1265., 1266., 1267., 1268., 1281., 1282.,
      1283., 1284., 1293., 1294., 1295., 1296., 1293., 1294., 1295., 1296.,
      1249., 1250., 1251., 1252., 1265., 1266., 1267., 1268., 1281., 1282.,
      1283., 1284., 1293., 1294., 1295., 1296., 1293., 1294., 1295., 1296.,
      1753., 1754., 1755., 1756., 1769., 1770., 1771., 1772., 1785., 1786.,
      1787., 1788., 1797., 1798., 1799., 1800., 1797., 1798., 1799., 1800.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 2013., 2014., 2015., 2016.,
      497.,  498.,  499.,  500.,  513.,  514.,  515.,  516.,  529.,  530.,
      531.,  532.,  541.,  542.,  543.,  544.,  541.,  542.,  543.,  544.,
      1001., 1002., 1003., 1004., 1017., 1018., 1019., 1020., 1033., 1034.,
      1035., 1036., 1045., 1046., 1047., 1048., 1045., 1046., 1047., 1048.,
      1289., 1290., 1291., 1292., 1305., 1306., 1307., 1308., 1321., 1322.,
      1323., 1324., 1333., 1334., 1335., 1336., 1333., 1334., 1335., 1336.,
      1577., 1578., 1579., 1580., 1593., 1594., 1595., 1596., 1609., 1610.,
      1611., 1612., 1621., 1622., 1623., 1624., 1621., 1622., 1623., 1624.,
      1793., 1794., 1795., 1796., 1809., 1810., 1811., 1812., 1825., 1826.,
      1827., 1828., 1837., 1838., 1839., 1840., 1837., 1838., 1839., 1840.,
      1793., 1794., 1795., 1796., 1809., 1810., 1811., 1812., 1825., 1826.,
      1827., 1828., 1837., 1838., 1839., 1840., 1837., 1838., 1839., 1840.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow11Stride4Forward, VALID3x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      761.,  762.,  763.,  764.,  777.,  778.,  779.,  780.,  1049., 1050.,
      1051., 1052., 1065., 1066., 1067., 1068., 2045., 2046., 2047., 2048.,
      2045., 2046., 2047., 2048., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 1305., 1306., 1307., 1308., 1321., 1322., 1323., 1324.,
      1593., 1594., 1595., 1596., 1609., 1610., 1611., 1612.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
